Situation-aware Edge Computing

Future wireless networks must cope with an increasing amount of data that needs to be transmitted to or from mobile devices. Furthermore, novel applications, e.g., augmented reality games or autonomous driving, require low latency and high bandwidth at the same time. To address these challenges, the paradigm of edge computing has been proposed. It brings computing closer to the users and takes advantage of the capabilities of telecommunication infrastructures, e.g., cellular base stations or wireless access points, but also of end user devices such as smartphones, wearables, and embedded systems. However, edge computing introduces its own challenges, e.g., economic and business-related questions or device mobility. Being aware of the current situation, i.e., the domain-specific interpretation of environmental information, makes it possible to develop approaches targeting these challenges. In this thesis, the novel concept of situation-aware edge computing is presented. It is divided into three areas: situation-aware infrastructure edge computing, situation-aware device edge computing, and situation-aware embedded edge computing. Therefore, the concepts of situation and situation-awareness are introduced. Furthermore, challenges are identified for each area, and corresponding solutions are presented. In the area of situation-aware infrastructure edge computing, economic and business-related challenges are addressed, since companies offering services and infrastructure edge computing facilities have to find agreements regarding the prices for allowing others to use them. In the area of situation-aware device edge computing, the main challenge is to find suitable nodes that can execute a service and to predict a node’s connection in the near future. Finally, to enable situation-aware embedded edge computing, two novel programming and data analysis approaches are presented that allow programmers to develop situation-aware applications. To show the feasibility, applicability, and importance of situation-aware edge computing, two case studies are presented. The first case study shows how situation-aware edge computing can provide services for emergency response applications, while the second case study presents an approach where network transitions can be implemented in a situation-aware manner

DTN7: An Open-Source Disruption-tolerant Networking Implementation of Bundle Protocol 7

In disruption-tolerant networking (DTN), data is transmitted in a store-carry-forward fashion from network node to network node. In this paper, we present an open source DTN implementation, called DTN7, of the recently released Bundle Protocol Version 7 (draft version 13). DTN7 is written in Go and provides features like memory safety and concurrent execution. With its modular design and interchangeable components, DTN7 facilitates DTN research and application development. Furthermore, we present results of a comparative experimental evaluation of DTN7 and other DTN systems including Serval, IBR-DTN, and Forban. Our results indicate that DTN7 is a flexible and efficient open-source multi-platform implementation of the most recent Bundle Protocol Version 7.Comment: 18th International Conference on Ad Hoc Networks and Wireless (AdHoc-Now 2019

Smart Street Lights and Mobile Citizen Apps for Resilient Communication in a Digital City

Currently, nearly four billion people live in urban areas. Since this trend is increasing, natural disasters or terrorist attacks in such areas affect an increasing number of people. While information and communication technology is crucial for the operation of urban infrastructures and the well-being of its inhabitants, current technology is quite vulnerable to disruptions of various kinds. In future smart cities, a more resilient urban infrastructure is imperative to handle the increasing number of hazardous situations. We present a novel resilient communication approach based on smart street lights as part of the public infrastructure. It supports people in their everyday life and adapts its functionality to the challenges of emergency situations. Our approach relies on various environmental sensors and in-situ processing for automatic situation assessment, and a range of communication mechanisms (e.g., public WiFi hotspot functionality and mesh networking) for maintaining a communication network. Furthermore, resilience is not only achieved based on infrastructure deployed by a digital city's municipality, but also based on integrating citizens through software that runs on their mobile devices (e.g., smartphones and tablets). Web-based zero-installation and platform-agnostic apps can switch to device-to-device communication to continue benefiting people even during a disaster situation. Our approach, featuring a covert channel for professional responders and the zero-installation app, is evaluated through a prototype implementation based on a commercially available street light.Comment: 2019 IEEE Global Humanitarian Technology Conference (GHTC

ReactiFi: Reactive Programming of Wi-Fi Firmware on Mobile Devices

Network programmability will be required to handle future increased network traffic and constantly changing application needs. However, there is currently no way of using a high-level, easy to use programming language to program Wi-Fi firmware. This impedes rapid prototyping and deployment of novel network services/applications and hinders continuous performance optimization in Wi-Fi networks, since expert knowledge is required for both the used hardware platforms and the Wi-Fi domain. In this paper, we present ReactiFi, a high-level reactive programming language to program Wi-Fi chips on mobile consumer devices. ReactiFi enables programmers to implement extensions of PHY, MAC, and IP layer mechanisms without requiring expert knowledge of Wi-Fi chips, allowing for novel applications and network protocols. ReactiFi programs are executed directly on the Wi-Fi chip, improving performance and power consumption compared to execution on the main CPU. ReactiFi is conceptually similar to functional reactive languages, but is dedicated to the domain-specific needs of Wi-Fi firmware. First, it handles low-level platform-specific details without interfering with the core functionality of Wi-Fi chips. Second, it supports static reasoning about memory usage of applications, which is important for typically memory-constrained Wi-Fi chips. Third, it limits dynamic changes of dependencies between computations to dynamic branching, in order to enable static reasoning about the order of computations. We evaluate ReactiFi empirically in two real-world case studies. Our results show that throughput, latency, and power consumption are significantly improved when executing applications on the Wi-Fi chip rather than in the operating system kernel or in user space. Moreover, we show that the high-level programming abstractions of ReactiFi have no performance overhead compared to manually written C code

Using Social Media to Estimate the Audience Sizes of Public Events for Crisis Management and Emergency Care

Public events such as soccer games, concerts, or street festivals attract large crowds of visitors. In an emergency situation, estimations about current events and their numbers of visitors are important to be able to react early and effectively by performing adequate countermeasures. Previous research has proposed ap-proaches to detect events like accidents and catastrophes by relying on user-generated content and reporting event-related information. To be proactive in case of an emergency, it is important to know what is happening in direct proximity, even if it is not yet affected by the catastrophe. Therefore, information about on-going events and numbers of visitors in the surrounding environment is indis-pensable. We develop a system design that allows collecting and merging event-related information from social media to provide estimations of the audience siz-es. We illustrate the potential of our approach by estimating the number of visi-tors of soccer games, fairs, street festivals, music festivals, and concerts, and by comparing it to the real numbers of visitors. Our results indicate that matching event-related user-generated content leads to improvements of the estimations. Finally, we demonstrate the usefulness of the system in a recent crisis scenario

OPPLOAD: Offloading Computational Workflows in Opportunistic Networks

Computation offloading is often used in mobile cloud computing, edge computing, and/or fog computing to cope with resource limitations of mobile devices in terms of computational power, storage, and energy. Computation offloading is particularly challenging in situations where network connectivity is periodic, intermittent, or error-prone. In this paper, we present OPPLOAD, a novel framework designed for offloading computational workflows in opportunistic networks that provide support for communication in such situations. The individual tasks forming a workflow can be assigned to particular remote execution platforms, called workers, either preselected ahead of time or decided just in time where a matching worker will automatically be assigned for the next task in the workflow. Workers announce their capabilities, i.e., tasks are only assigned to capable workers. Furthermore, tasks of a workflow can be executed on multiple workers that are automatically selected to balance the overall load. OPPLOAD also offers the ability to handle several types of error and exceptions appropriately. Our Python implementation of OPPLOAD, which uses the Serval Mesh to handle networking and routing, is publicly available as open source software. The results of our experimental evaluation demonstrate the feasibility of our approach

ProgDTN: Programmable Disruption-tolerant Networking

Existing routing algorithms for disruption-tolerant networking (DTN) have two main limitations: (a) a particular DTN routing algorithm is typically designed to achieve very good performance in a specific scenario, but has limited performance in other scenarios, and (b) DTN routing algorithms do not take advantage of network programmability to profit from its benefits. We present ProgDTN, a novel approach to support programmable disruption-tolerant networking by allowing network operators to implement and adapt routing algorithms without knowledge of a router’s interior workings using the popular JavaScript language. To consider the specific properties of a particular application scenario, network operators can incorporate context information of DTN bundles and nodes in their routing algorithms. ProgDTN is based on DTN7, a flexible and efficient open-source, platform-independent implementation of the Bundle Protocol version 7. Our experimental evaluation demonstrates that using ProgDTN to tailor a routing algorithm to a particular scenario achieves excellent results of up to 99.9% delivery ratio while reducing unnecessary transmissions by 92.9%. ProgDTN’s implementation, our tailored scenario-specific routing algorithm, and code/data fragments for our experiments are released under permissive open-source licenses

DTN-RPC: Remote Procedure Calls for Disruption-Tolerant Networking

Remote Procedure Calls (RPCs) realize client-server interactions via a request-response message-passing protocol. They simplify distributed application programming by eliminating the need for explicitly having to code the details of a remote interaction. However, none of the existing RPC implementations are designed to work properly for Delay/Disruption-Tolerant Networking (DTN) where network connectivity is periodic, intermittent, and prone to disruptions. In this paper, we present DTN- RPC, a new approach to provide RPCs for DTN environments. DTN-RPC relies on (a) control and data channels to cope with potentially short contact durations in DTN where large amounts of data cannot be transmitted, (b) explicit and implicit modes to address remote servers, (c) Non-DTN and DTN transport protocols for issuing calls and receiving results, and (d) predicates that servers check to decide whether a procedure should be executed. The implementation of DTN-RPC is based on Serval, an open-source, disruption-tolerant wireless ad-hoc networking system. Our experimental results indicate that the measured CPU and network overheads for DTN-RPC are reasonably low so that it can be executed on smartphones or routers, and that the round-trip times and the number of successful RPCs are highly satisfactory in dynamic networks with unstable links